package com.yidu.hbatsft.service.impl;

import com.github.pagehelper.PageHelper;
import com.yidu.hbatsft.dao.AtsAttachAuditMapper;
import com.yidu.hbatsft.dao.AtsAttachmentEmpMapper;
import com.yidu.hbatsft.dao.AtsAttachmentMapper;
import com.yidu.hbatsft.dao.AtsFileDataMapper;
import com.yidu.hbatsft.domain.*;
import com.yidu.hbatsft.service.AtsAttachmentService;
import com.yidu.privilege.Dao.UserDao;
import com.yidu.privilege.Domain.User;
import com.yidu.utils.Tools;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

/**
 * ClassName:AtsAttachmentServiceImpl
 * Package:com.yidu.hbatsft.service.impl
 * Description: 附件审核功能类
 *
 * @Date 2019-11-04 14:37
 * @Author 陈熠
 */
@Service
public class AtsAttachmentServiceImpl implements AtsAttachmentService {

    /**
     * 附件表映射
     */
    @Resource
    AtsAttachmentMapper atsAttachmentMapper;
    /**
     *文件表映射
     */
    @Resource
    AtsFileDataMapper atsFileDataMapper;
    /**
     * 用户表dao
     */
    @Resource
    private UserDao userDao;
    /**
     * 附件用户关联表映射
     */
    @Resource
    AtsAttachmentEmpMapper attachmentEmpMapper;
    /**
     *  附件审核表映射
     */
    @Resource
    AtsAttachAuditMapper atsAttachAuditMapper;

    private static final String ATTACH_TYPE1 = "10";
    private static final String ATTACH_TYPE2 = "20";
    private static final String ATTACH_TYPE3 = "25";
    private static final String ATTACH_TYPE4 = "30";


    /**
     * 根据id查询附件表
     * @param attachId 功能id
     * @return  功能对象
     */
    @Override
    public AtsAttachment selectByPrimaryKey(Integer attachId) {
        return atsAttachmentMapper.selectByPrimaryKey(attachId);
    }

    /**
     * 根据附件id查询关联的用户id；
     * 用于修改页面，关联需要的发布对象，
     * @param attachId 附件id
     * @return 用户id集合
     */
    @Override
    public String[] findUserIdsByAttachId(Integer attachId) {
        //根据附件id，查询附件关联表
        List<AtsAttachmentEmp> list = attachmentEmpMapper.selectByAttachId(attachId);
        //创建一个附件id数组
        String[] treeId = new String[list.size()];
        //循环关联表集合，给附件id数组添加id，
        for (int i = 0; i < list.size(); i++) {
            AtsAttachmentEmp attachmentEmp =  list.get(i);
            treeId[i] = attachmentEmp.getUserId();
        }
        return treeId;
    }

    /**
     * 查询首页所需要的信息
     *
     * @param attachmentCondition 用户id，附件类别，分页参数
     * @return 附件信息
     */
    @Override
    public List<AtsAttachment> selectHomePageByUserId(AtsAttachmentCondition attachmentCondition) {

        return atsAttachmentMapper.selectHomePageByUserId(attachmentCondition);
    }


    /**
     * 查询所有，用于查看功能
     * @param attachmentCondition 辅助功能条件类
     * @return 附件表集合对象
     */
    @Override
    public List<AtsAttachment> selectTypeAll(AtsAttachmentCondition attachmentCondition) {
        //分页插件，startPage
        PageHelper.startPage(attachmentCondition.getPage(),attachmentCondition.getLimit());
        return atsAttachmentMapper.selectTypeAll(attachmentCondition);

    }

    /**
     * 查询总行数,用于查看功能
     * @param attachmentCondition 辅助功能条件类
     * @return 总行数
     */
    @Override
    public int selectCount(AtsAttachmentCondition attachmentCondition) {

       return atsAttachmentMapper.selectCount(attachmentCondition);

    }


    /**
     * 根据用户id查询所拥有的附件表
     * 用于修改功能
     * @param attachmentCondition 用户id
     * @return 附件表信息。
     */
    @Override
    public List<AtsAttachment> selectByUserId(AtsAttachmentCondition attachmentCondition) {
        //分页插件，startPage
        PageHelper.startPage(attachmentCondition.getPage(),attachmentCondition.getLimit());

        return atsAttachmentMapper.selectByUserId(attachmentCondition);
    }

    /**
     * 根据用户id查询所拥有的附件表的行数
     * 用于修改功能
     * @param attachmentCondition 用户id
     * @return 附件表总行数。
     */
    @Override
    public int selectByUserIdCount(AtsAttachmentCondition attachmentCondition) {

        return atsAttachmentMapper.selectByUserIdCount(attachmentCondition);

    }

    /**
     * 根据附件表类型查询所拥有的附件表
     * 用于审核功能
     * @param attachmentCondition 附件表类型，page
     * @return 附件表信息。
     */
    @Override
    public List<AtsAttachment> selectByAttachType(AtsAttachmentCondition attachmentCondition) {
        //分页插件，startPage
        PageHelper.startPage(attachmentCondition.getPage(),attachmentCondition.getLimit());

        return atsAttachmentMapper.selectByAttachType(attachmentCondition);

    }

    /**
     * 根据附件表类型查询所拥有的附件表的行数
     * 用于审核功能
     * @param attachmentCondition 用户id
     * @return 附件表总行数。
     */
    @Override
    public int selectByAttachTypeCount(AtsAttachmentCondition attachmentCondition) {

        return atsAttachmentMapper.selectByAttachTypeCount(attachmentCondition);

    }



    /**
     * 批量删除加删除
     *
     * @param attachmentCondition 辅助功能条件类
     * @return 删除条数
     */
    @Override
    public int deleteByAttachId(AtsAttachmentCondition attachmentCondition) {
        //得到想要删除的附件id，根据‘，’得到id数组
        String[] strings = attachmentCondition.getDeleteAttachIds().split(",");
        //删除状态，0为失败
        int state = 0;
        //循环附件id数组
        for(String i: strings){
            //条件类对象
            AtsAttachmentCondition attachmentCondition1 = new AtsAttachmentCondition();
            //文件类对象
            AtsFileData atsFileData = new AtsFileData();
            //附件关联表对象
            AtsAttachmentEmp attachmentEmp = new AtsAttachmentEmp();
            //将附件id保存在条件对象
            attachmentCondition1.setAttachId(i);
            //将保存附件id的条件对象，进行删除指令,删除附件表
            atsAttachmentMapper.deleteByAttachId(attachmentCondition1);
            //将附件id保存在关联表
            attachmentEmp.setAttachId(Integer.valueOf(i));
            //将逻辑删除，设置关联表Isva为无效0
            attachmentEmp.setIsva(0);
            //将关联表对象，附件关联表映射进行逻辑删除，通过附件id，修改Isva,得到修改状态
            state = attachmentEmpMapper.updateIsvaByPrimaryKey(attachmentEmp);
            //将附件id保存在文件对象中
            atsFileData.setFileTypeId(i);
            //将文件对象，查询文件数量，判断是否需要进行文件删除；
            int fileCount = atsFileDataMapper.selectFileCount(atsFileData);
            if (fileCount > 0){
                //将文件对象，附件映射进行逻辑删除，保存修改状态。
                state = atsFileDataMapper.updateFileIsva(atsFileData);
            }


        }
        return  state;
    }

    /**
     * 新增，根据条件判断新增
     *
     * @param record 新增数据对象
     * @param condition 用户id和姓名
     * @return 新增状态，1为有效
     */
    @Override
    public AtsAttachmentCondition insertSelective(AtsAttachment record, AtsAttachmentCondition condition) {
        //创建条件类
        AtsAttachmentCondition attachmentCondition = new AtsAttachmentCondition();
        //使用工具类，得到附件id；
        int attachId = Tools.getRandomNumber(1000000000);
        //设置附件的创始时间
        record.setCreatTime(new Date());
        //设置附件初始为有效
        record.setIsva(1);
        //设置附件id
        record.setAttachId(attachId);
        //设置需要审核，状态码20
        record.setAuditState(20);
        //判断是否设置有效时间,
        if (Tools.isEmpty(record.getAttachValidTime())){
            //自拟一个有效时间，
            record.setAttachValidTime("2999-01-01");
        }

        //将附件表对象，附件映射进行新增。
        atsAttachmentMapper.insertSelective(record);
        //得到需要发布的用户ids
        String treeUserIds = condition.getTreeUserIds();
        //得到需要发布的用户姓名，
        String treeUserTitles = condition.getTreeUserTitles();
        //根据字节‘，‘，对用户ids，用户姓名进行分组。
        String[] string1 = treeUserIds.split(",");
        String[] string2 = treeUserTitles.split(",");
        //对用户id数组进行for循环
        for(int i = 0; i < string1.length; i++){
            //得到用户id和用户姓名
            String userId = string1[i];
            String userName = string2[i];
            //创建关联表对象，保存附件id，用户id，用户姓名，设置是否查看初始状态为0，设置是否有效初始状态为1
            AtsAttachmentEmp attachmentEmp = new AtsAttachmentEmp(attachId,userId,userName,"0",1);
            //将关联表对象， 附件关联表映射进行文件新增
            attachmentEmpMapper.insertSelective(attachmentEmp);
        }
        //设置需要返回的状态成功为1，返回文件新增需要的附件id和附件类型。
        attachmentCondition.setAttachState("1");
        attachmentCondition.setAttachId(String.valueOf(attachId));
        attachmentCondition.setAttachType(record.getAttachType());
        return attachmentCondition;

    }

    /**
     * 根据附件id修改附件，附件关联表，文件
     *  用于修改功能需要的附件信息
     * @param record 修改对象
     * @return 修改状态
     */
    @Override
    public AtsAttachmentCondition updateByPrimaryKeySelective(AtsAttachment record, AtsAttachmentCondition condition) {
        //得到文件类型
        String fileType = record.getAttachType();
        //文件id
        String fileTypeId = String.valueOf(record.getAttachId());
        //创建条件对象
        AtsAttachmentCondition attachmentCondition = new AtsAttachmentCondition();
        //通过文件id数组，判断是否有需要删除的文件，
        if (!Tools.isEmpty(condition.getFileDataIds())){
            //得到需要删除的文件id，然后通过字节’，‘得到文件id数组
            String fileIds = condition.getFileDataIds();
            String[] strings = fileIds.split(",");
            //对文件id数组for循环
            for (String string : strings) {
                //创建文件对象，设置文件id，Isva为无效；
                AtsFileData atsFileData = new AtsFileData();
                atsFileData.setFileId(string);
                atsFileData.setIsva(0);
                //将文件对象，文件映射进行：通过文件id动态修改方法
                atsFileDataMapper.updateByPrimaryKeySelective(atsFileData);
            }

        }
        //将附件表，附件映射进行：通过附件id动态修改附件
        atsAttachmentMapper.updateByPrimaryKeySelective(record);
        //创建附件关联表，设置附件id，Isva为0
        AtsAttachmentEmp attachmentEmp = new AtsAttachmentEmp();
        attachmentEmp.setAttachId(record.getAttachId());
        attachmentEmp.setIsva(0);
        //将附件关联表，附件关联映射进行：通过附件id修改附件关联表Isva
        attachmentEmpMapper.updateIsvaByPrimaryKey(attachmentEmp);
        //通过条件对象得到用户ids和用户姓名，然后通过字节’，‘得到相应数组
        String treeUserIds = condition.getTreeUserIds();
        String treeUserTitles = condition.getTreeUserTitles();
        String[] string1 = treeUserIds.split(",");
        String[] string2 = treeUserTitles.split(",");
        //对用户id数组进行for循环
        for(int i = 0; i < string1.length; i++){
            //得到用户id和用户姓名
            String userId = string1[i];
            String userName = string2[i];
            //创建关联表对象，保存附件id，用户id，用户姓名，设置是否查看初始状态为0，设置是否有效初始状态为1
            AtsAttachmentEmp attachmentEmp2 = new AtsAttachmentEmp(record.getAttachId(),userId,userName,"0",1);
            //将关联表对象2， 附件关联表映射进行文件新增
            attachmentEmpMapper.insertSelective(attachmentEmp2);
        }
        //设置需要返回的状态成功为1，返回文件新增需要的附件id和附件类型。
        attachmentCondition.setAttachState("1");
        attachmentCondition.setAttachId(fileTypeId);
        attachmentCondition.setAttachType(fileType);

        return attachmentCondition;
    }

    /**
     * 修改文件对象，删除操作
     *
     * @param atsFileData 文件对象
     * @return 结果
     */
    @Override
    public AtsAttachmentCondition deleteFileData(AtsFileData atsFileData) {
        //创建条件对象，
        AtsAttachmentCondition attachmentCondition = new AtsAttachmentCondition();
        //数组文件对象Isva无效，状态码为零
        atsFileData.setIsva(0);
        //将文件对象进行逻辑删除，文件映射进行：通过文件id动态修改
        atsFileDataMapper.updateByPrimaryKeySelective(atsFileData);
        //设置需要返回的状态码
        attachmentCondition.setFileDataState("1");

        return attachmentCondition;
    }

    /**
     * 根据id查询相关文件
     *
     * @param record 文件id，文件类型
     * @return 相关文件集合
     */
    @Override
    public List<AtsFileData> selectAttachFileAll(AtsFileData record) {
        return atsFileDataMapper.selectAttachFileAll(record);
    }

    /**
     * 表格删除时，对应的文件删除
     *
     * @param record 文件所属类型id
     * @return 结果
     */
    @Override
    public int updateFileIsva(AtsFileData record) {
        return atsFileDataMapper.updateFileIsva(record);
    }

    /**
     * 根据提交查询相应文件数量；
     *
     * @param record 文件id，文件类型
     * @return 文件数量
     */
    @Override
    public int selectFileCount(AtsFileData record) {
        return atsFileDataMapper.selectFileCount(record);
    }

    /**
     * 查询所有用户；
     *  用于发布对象所需要的用户
     * @return 用户树形控件需要的json格式数据
     */
    @Override
    public List<Map<String, Object>> findAllUsers() {
        //创建父类节点，初始为0
        int parentNode = 0;
        //通过userDao层的方法finAll2得到用户list集合
        List<User> list = userDao.finAll2();
        //创建一个包含Map集合的list集合
        List<Map<String,Object>> list1 = new ArrayList<Map<String,Object>>();
        //java8，list通过stream方法转变为流，然后通过filter方法对list集合内的user对象的UsType进行非空过滤，然后通过college接收一个实例，实例里面使用Collectors接口，调用groupingBy方法根据user对象的UsType进行分组，得到Map<UsType字符,User对象>集合
        Map<String, List<User>> map = list.stream().filter((User user) -> !Tools.isEmpty(user.getUsType())).collect(Collectors.groupingBy(User::getUsType));
        //得到map集合的所有的key，然后将包含UsType用户类型的key进行for循环
        Set set = map.keySet();
        for (Object o : set) {
            //map集合通过key得到，一个用户类型的list用户集合
            List<User> users = map.get(o);
            //每次循环，让父节点加一
            parentNode = parentNode + 1;
            //创建一个普通的map1集合
            Map<String,Object> map1 = new HashMap<String,Object>();
            //创建一个包含Map集合的list2集合
            List<Map<String,Object>> list2 = new ArrayList<Map<String,Object>>();
            //循环users集合，给list2添加子节点
            for (int i = 0; i < users.size(); i++) {
                //得到用户
                User user =  users.get(i);
                //创建map2集合，添加<'title',用户姓名>,<"id",用户id>,然后将map2添加到list2集合中；
                Map<String,Object> map2 = new HashMap<String,Object>();
                map2.put("title", user.getUsName());
                map2.put("id", user.getUsId());
                list2.add(map2);
            }
            //给map1集合，添加<"title",用户类型>,<"id",父节点>,<"children",子对象集合list2>,然后将map1添加到list1集合中。
            map1.put("title",o);
            map1.put("id",parentNode);
            map1.put("children",list2);
            list1.add(map1);
        }

        return list1;
    }

    /**
     * 修改文件对象，修改操作
     *
     * @param atsFileData 文件对象
     * @return 文件id
     */
    @Override
    public AtsAttachmentCondition updateFileData(AtsFileData atsFileData) {
        //创建条件对象
        AtsAttachmentCondition attachmentCondition = new AtsAttachmentCondition();
        //将文件对象，文件映射进行：通过文件id动态修改文件表
        atsFileDataMapper.updateByPrimaryKeySelective(atsFileData);
        //设置修改状态
        attachmentCondition.setFileDataState("1");

        return attachmentCondition;
    }

    /**
     * 新增文件对象
     *
     * @param atsFileData 文件对象
     * @return 文件id
     */
    @Override
    public AtsAttachmentCondition insertFileData(AtsFileData atsFileData) {
        AtsAttachmentCondition attachmentCondition = new AtsAttachmentCondition();
        //通过工具类得到文件id，设置文件对象的文件id，Isva，创建时间。
        String fileDataId = Tools.getRandomUUID();
        atsFileData.setFileId(fileDataId);
        atsFileData.setIsva(1);
        atsFileData.setCreatTime(new Date());
        //将文件对象，文件映射进行：新增；
        int fileDataState = atsFileDataMapper.insertSelective(atsFileData);
        //设置新增状态。
        attachmentCondition.setFileDataState(String.valueOf(fileDataState));

        return attachmentCondition;
    }

    /**
     * 对文件进行编译
     * @param atsFileData 编译对象
     * @return 编译后，存储的文件地址
     */
    @Override
    public AtsFileData fileCompile(AtsFileData atsFileData){
        /*String fileSite = atsFileData.getFileSite();
        String fileSuffix = atsFileData.getFileSuffix();
        String filePath = "";

        if ("xls".equals(fileSuffix) || "xlsx".equals(fileSuffix) || "xlsm".equals(fileSuffix)){
            filePath = PdfUtil.exceOfPdf2(fileSite);
            if ("1".equals(filePath)){
                atsFileData.setFileCompile("1");
            }else {
                atsFileData.setFileCompile("3");
            }
        }else if ("ppt".equals(fileSuffix) || "pptx".equals(fileSuffix) || "pps".equals(fileSuffix) || "ppsx".equals(fileSuffix) || "ppa".equals(fileSuffix) || "ppam".equals(fileSuffix) || "pot".equals(fileSuffix) || "potx".equals(fileSuffix) || "thnx".equals(fileSuffix)){
            filePath = PdfUtil.pptOfpdf2(fileSite);
            if ("1".equals(filePath)){
                atsFileData.setFileCompile("1");
            }else {
                atsFileData.setFileCompile("3");
            }
        }else if ("Doc".equals(fileSuffix) || "Docx".equals(fileSuffix) || "RTF".equals(fileSuffix) || "HTML".equals(fileSuffix) || "OpenDocument".equals(fileSuffix) || "XPS".equals(fileSuffix) || "EPUB".equals(fileSuffix) || "OOXL".equals(fileSuffix) || "TXT".equals(fileSuffix)){
            filePath = PdfUtil.docOfPdf2(fileSite);
            if ("1".equals(filePath)){
                atsFileData.setFileCompile("1");
            }else {
                atsFileData.setFileCompile("3");
            }
        }else if ("pdf".equals(fileSuffix)){
            atsFileData.setFileCompile("3");
        }else if ("mp4".equals(fileSuffix) || "webm".equals(fileSuffix) || "ogg".equals(fileSuffix) ){
            atsFileData.setFileCompile("4");
        }else if ("png".equals(fileSuffix) || "gif".equals(fileSuffix) || "jpg".equals(fileSuffix) || "bmp".equals(fileSuffix) || "jpeg".equals(fileSuffix)){
            atsFileData.setFileCompile("2");
        } else{
            atsFileData.setFileCompile("1");
        }
        atsFileData.setFilePath(fileSite);
        atsFileDataMapper.updateByPrimaryKeySelective(atsFileData);*/
        return atsFileData;
    }

    /**
     * 根据附件表id查询审核集合
     *
     * @param attachmentCondition 附件表id信息
     * @return 审核集合
     */
    @Override
    public List<AtsAttachAudit> selectByAttachId(AtsAttachmentCondition attachmentCondition) {
        //分页插件，startPage
        PageHelper.startPage(attachmentCondition.getPage(),attachmentCondition.getLimit());

        return atsAttachAuditMapper.selectByAttachId(attachmentCondition);
    }

    /**
     * 根据附件表id查询审核总行数
     *
     * @param attachmentCondition 附件表id信息
     * @return 审核总行数
     */
    @Override
    public int selectByAttachIdCount(AtsAttachmentCondition attachmentCondition) {
        return atsAttachAuditMapper.selectByAttachIdCount(attachmentCondition);
    }

    /**
     * 新增审核
     *
     * @param atsAttachAudit 审核信息
     * @return 新增条数
     */
    @Override
    public int insertAudit(AtsAttachAudit atsAttachAudit) {
        //通过工具类Tools，创建审核id
        int auditId = Tools.getRandomNumber(1000000000);
        //设置创建时间，Isva，审核id
        atsAttachAudit.setCreatTime(new Date());
        atsAttachAudit.setIsva(1);
        atsAttachAudit.setAuditId(String.valueOf(auditId));
        //得到附件id，审核状态；
        String attachId = atsAttachAudit.getAuditAttachId();
        String attachState = atsAttachAudit.getAuditState();
        //创建附件对象，设置附件审核状态和附件id
        AtsAttachment atsAttachment = new AtsAttachment();
        atsAttachment.setAuditState(Integer.valueOf(attachState));
        atsAttachment.setAttachId(Integer.valueOf(attachId));
        //通过附件id动态修改附件审核状态
        atsAttachmentMapper.updateByPrimaryKeySelective(atsAttachment);
        //修改完成后，对审核表进行新增。
        return atsAttachAuditMapper.insertSelective(atsAttachAudit);
    }


}
